"""评估引擎接口抽象层"""
from abc import ABC, abstractmethod
from typing import List, Dict, Any, Optional
from app.models.user import UserProfile
from app.models.training import AnswerRecord, TrainingSession
from app.models.assessment import InitialAssessmentResult, WeaknessAnalysis


class EvaluationEngine(ABC):
    """评估引擎抽象基类"""
    
    @abstractmethod
    async def evaluate_initial_assessment(
        self,
        user_id: str,
        assessment_data: Dict[str, Any]
    ) -> InitialAssessmentResult:
        """
        评估初始能力
        
        Args:
            user_id: 用户ID
            assessment_data: 评估数据（答题记录、时间等）
            
        Returns:
            初始评估结果
        """
        pass
    
    @abstractmethod
    async def analyze_weaknesses(
        self,
        user_id: str,
        answer_records: List[AnswerRecord],
        time_period_days: int = 30
    ) -> WeaknessAnalysis:
        """
        分析薄弱环节
        
        Args:
            user_id: 用户ID
            answer_records: 答题记录列表
            time_period_days: 分析的时间范围（天数）
            
        Returns:
            薄弱环节分析结果
        """
        pass
    
    @abstractmethod
    async def predict_accuracy(
        self,
        user_id: str,
        historical_data: List[Dict[str, Any]],
        days_ahead: int = 30
    ) -> Dict[str, Any]:
        """
        预测正确率（基于学习曲线理论）
        
        Args:
            user_id: 用户ID
            historical_data: 历史数据
            days_ahead: 预测未来天数
            
        Returns:
            预测结果
        """
        pass
    
    @abstractmethod
    async def classify_error_type(
        self,
        question_content: str,
        user_answer: str,
        correct_answer: str,
        context: Optional[Dict[str, Any]] = None
    ) -> Dict[str, Any]:
        """
        分类错误类型
        
        Args:
            question_content: 题目内容
            user_answer: 用户答案
            correct_answer: 正确答案
            context: 可选上下文
            
        Returns:
            错误分类结果
        """
        pass
    
    @abstractmethod
    async def calculate_thinking_quality(
        self,
        user_id: str,
        recent_sessions: List[TrainingSession]
    ) -> float:
        """
        计算思维质量分数
        
        Args:
            user_id: 用户ID
            recent_sessions: 最近的训练会话列表
            
        Returns:
            思维质量分数（0-100）
        """
        pass


class MockEvaluationEngine(EvaluationEngine):
    """模拟评估引擎实现（用于开发测试）"""
    
    async def evaluate_initial_assessment(
        self,
        user_id: str,
        assessment_data: Dict[str, Any]
    ) -> InitialAssessmentResult:
        """模拟初始能力评估"""
        # 模拟评估逻辑
        scores = {
            "legal_basics": 75.0,
            "thinking_rigor": 68.0,
            "answer_speed": 72.0,
            "knowledge_breadth": 70.0
        }
        overall = sum(scores.values()) / len(scores)
        
        return InitialAssessmentResult(
            assessment_id=f"assess_{user_id}_001",
            user_id=user_id,
            assessment_type="initial",
            legal_basics_score=scores["legal_basics"],
            thinking_rigor_score=scores["thinking_rigor"],
            answer_speed_score=scores["answer_speed"],
            knowledge_breadth_score=scores["knowledge_breadth"],
            overall_score=overall,
            assessed_at=None,  # 实际应该使用datetime.now()
            recommendations=[
                "加强法律基础理论学习",
                "提高思维严谨性训练",
                "扩大知识面广度"
            ]
        )
    
    async def analyze_weaknesses(
        self,
        user_id: str,
        answer_records: List[AnswerRecord],
        time_period_days: int = 30
    ) -> WeaknessAnalysis:
        """模拟薄弱环节分析"""
        # 统计错误分布
        error_by_category = {}
        for record in answer_records:
            if not record.is_correct and record.error_category:
                error_by_category[record.error_category] = \
                    error_by_category.get(record.error_category, 0) + 1
        
        weak_areas = [
            {
                "area": "contract_law",
                "score": 62.0,
                "priority": "high",
                "error_count": error_by_category.get("合同法", 0)
            },
            {
                "area": "criminal_procedure",
                "score": 58.0,
                "priority": "high",
                "error_count": error_by_category.get("刑事诉讼", 0)
            }
        ]
        
        return WeaknessAnalysis(
            user_id=user_id,
            assessment_type="weakness",
            weak_areas=weak_areas,
            strong_areas=[
                {
                    "area": "civil_law",
                    "score": 80.0,
                    "priority": "low"
                }
            ],
            recommendations=[
                "加强合同法基础理论学习",
                "重点练习刑事诉讼程序题目"
            ],
            analyzed_at=None
        )
    
    async def predict_accuracy(
        self,
        user_id: str,
        historical_data: List[Dict[str, Any]],
        days_ahead: int = 30
    ) -> Dict[str, Any]:
        """模拟正确率预测（基于学习曲线）"""
        if not historical_data:
            return {
                "current_accuracy": 70.0,
                "predicted_accuracy": 75.0,
                "confidence_interval": {"lower": 73.0, "upper": 77.0}
            }
        
        # 简单的线性预测
        current = historical_data[-1].get("accuracy", 70.0)
        improvement_rate = 0.2  # 每天提升0.2%
        predicted = min(95.0, current + (improvement_rate * days_ahead))
        
        return {
            "current_accuracy": current,
            "predicted_accuracy": predicted,
            "confidence_interval": {
                "lower": predicted - 2.0,
                "upper": min(95.0, predicted + 2.0)
            },
            "learning_curve": [
                {"day": i, "predicted_accuracy": current + (improvement_rate * i)}
                for i in range(0, days_ahead + 1, 7)
            ]
        }
    
    async def classify_error_type(
        self,
        question_content: str,
        user_answer: str,
        correct_answer: str,
        context: Optional[Dict[str, Any]] = None
    ) -> Dict[str, Any]:
        """模拟错误类型分类"""
        # 简单的分类逻辑
        error_types = ["knowledge", "thinking", "technique", "attention"]
        # 模拟：随机选择一个错误类型（实际应该基于AI分析）
        import random
        error_type = random.choice(error_types)
        
        return {
            "error_type": error_type,
            "error_category": {
                "knowledge": "法律条文理解错误",
                "thinking": "逻辑推理错误",
                "technique": "答题技巧不足",
                "attention": "审题不仔细"
            }.get(error_type, "未知错误"),
            "confidence": 0.85,
            "details": {
                "reason": f"用户答案与正确答案不符，判断为{error_type}类型错误"
            }
        }
    
    async def generate_detailed_error_analysis(
        self,
        question_content: str,
        question_options: List[str],
        user_answer: str,
        correct_answer: str,
        explanation: str,
        knowledge_points: List[str] = None
    ) -> Dict[str, Any]:
        """
        生成详细的错误分析，包括做题思路、正确答案解释和错误点分析
        
        Args:
            question_content: 题目内容
            question_options: 题目选项列表
            user_answer: 用户答案
            correct_answer: 正确答案
            explanation: 标准解析
            knowledge_points: 知识点列表
            
        Returns:
            详细的错误分析结果
        """
        from app.ai.llm_service import get_llm_service
        llm_service = get_llm_service()
        
        # 构建详细的错误分析提示词
        analysis_prompt = f"""
你是一位资深的法考培训专家，请对以下错题进行详细分析。

【题目内容】
{question_content}

【题目选项】
{chr(10).join(question_options) if question_options else '（无选项信息）'}

【用户答案】
{user_answer}

【正确答案】
{correct_answer}

【标准解析】
{explanation}

【相关知识点】
{', '.join(knowledge_points) if knowledge_points else '（无知识点信息）'}

请从以下三个方面进行详细分析：

1. **做题思路分析**：
   - 分析这道题的正确解题思路应该是什么
   - 应该从哪些角度分析题目
   - 需要识别哪些关键信息
   - 应该运用哪些法律知识

2. **正确答案解释**：
   - 详细解释为什么正确答案是正确的
   - 说明正确答案涉及的法律条文和原理
   - 解释正确答案与题目条件的对应关系
   - 说明其他选项为什么是错误的（如果适用）

3. **用户答案错误分析**：
   - 指出用户答案具体哪里错了
   - 分析用户可能的错误原因（是理解偏差、记忆错误、逻辑错误等）
   - 说明用户答案与正确答案的区别
   - 指出用户可能存在的知识盲点或思维误区

请以结构化的方式组织回答，确保分析详细、准确、有针对性。
"""
        
        try:
            # 使用LLM生成详细分析
            if hasattr(llm_service, 'generate_text'):
                detailed_analysis = await llm_service.generate_text(
                    analysis_prompt,
                    max_tokens=1500,
                    temperature=0.7
                )
            else:
                # 如果没有LLM服务，使用基础分析
                detailed_analysis = self._generate_basic_error_analysis(
                    question_content, user_answer, correct_answer, explanation
                )
        except Exception as e:
            print(f"生成详细错误分析失败: {e}")
            # 使用基础分析作为备选
            detailed_analysis = self._generate_basic_error_analysis(
                question_content, user_answer, correct_answer, explanation
            )
        
        # 解析分析结果（尝试提取结构化信息）
        analysis_sections = self._parse_analysis_text(detailed_analysis)
        
        return {
            "detailed_analysis": detailed_analysis,
            "thinking_approach": analysis_sections.get("thinking_approach", ""),
            "correct_answer_explanation": analysis_sections.get("correct_explanation", explanation),
            "error_analysis": analysis_sections.get("error_analysis", ""),
            "knowledge_gaps": knowledge_points if knowledge_points else [],
            "improvement_suggestions": analysis_sections.get("suggestions", [])
        }
    
    def _generate_basic_error_analysis(
        self,
        question_content: str,
        user_answer: str,
        correct_answer: str,
        explanation: str
    ) -> str:
        """生成基础错误分析（当LLM不可用时）"""
        return f"""
【做题思路分析】
解答这道题需要仔细分析题目条件，识别关键法律事实，并运用相关法律知识进行判断。

【正确答案解释】
正确答案是：{correct_answer}
{explanation}

【用户答案错误分析】
您选择的答案是：{user_answer}，这与正确答案不符。
可能的原因包括：
1. 对相关法律条文的理解不够准确
2. 未能正确识别题目中的关键信息
3. 逻辑推理过程中存在偏差

建议您：
- 仔细阅读题目解析，理解正确答案的法律依据
- 复习相关知识点，加深对法律条文的理解
- 多做类似题目，提高解题能力
"""
    
    async def generate_correct_answer_analysis(
        self,
        question_content: str,
        question_options: List[str],
        user_answer: str,
        correct_answer: str,
        explanation: str,
        knowledge_points: List[str] = None
    ) -> Dict[str, Any]:
        """
        生成正确答案的详细分析，包括做题思路和为什么正确
        
        Args:
            question_content: 题目内容
            question_options: 题目选项列表
            user_answer: 用户答案（正确答案）
            correct_answer: 正确答案
            explanation: 标准解析
            knowledge_points: 知识点列表
            
        Returns:
            正确答案的详细分析结果
        """
        from app.ai.llm_service import get_llm_service
        llm_service = get_llm_service()
        
        # 构建正确答案分析提示词
        analysis_prompt = f"""
你是一位资深的法考培训专家，请对以下正确答题进行详细分析。

【题目内容】
{question_content}

【题目选项】
{chr(10).join(question_options) if question_options else '（无选项信息）'}

【用户答案】（正确答案）
{user_answer}

【正确答案】
{correct_answer}

【标准解析】
{explanation}

【相关知识点】
{', '.join(knowledge_points) if knowledge_points else '（无知识点信息）'}

请从以下两个方面进行详细分析：

1. **做题思路分析**：
   - 分析这道题的正确解题思路是什么
   - 应该从哪些角度分析题目
   - 需要识别哪些关键信息
   - 应该运用哪些法律知识
   - 解题的关键步骤是什么

2. **为什么答案正确**：
   - 详细解释为什么这个答案是正确的
   - 说明正确答案涉及的法律条文和原理
   - 解释正确答案与题目条件的对应关系
   - 说明其他选项为什么是错误的（如果适用）
   - 强调涉及的核心法律知识点

请以结构化的方式组织回答，确保分析详细、准确、有针对性，帮助学员巩固正确的解题思路。
"""
        
        try:
            # 使用LLM生成详细分析
            if hasattr(llm_service, 'generate_text'):
                detailed_analysis = await llm_service.generate_text(
                    analysis_prompt,
                    max_tokens=1500,
                    temperature=0.7
                )
            else:
                # 如果没有LLM服务，使用基础分析
                detailed_analysis = self._generate_basic_correct_analysis(
                    question_content, user_answer, correct_answer, explanation
                )
        except Exception as e:
            print(f"生成正确答案分析失败: {e}")
            # 使用基础分析作为备选
            detailed_analysis = self._generate_basic_correct_analysis(
                question_content, user_answer, correct_answer, explanation
            )
        
        # 解析分析结果（尝试提取结构化信息）
        analysis_sections = self._parse_analysis_text(detailed_analysis)
        
        return {
            "detailed_analysis": detailed_analysis,
            "thinking_approach": analysis_sections.get("thinking_approach", ""),
            "correct_answer_explanation": analysis_sections.get("correct_explanation", explanation),
            "knowledge_points": knowledge_points if knowledge_points else [],
            "reinforcement_suggestions": analysis_sections.get("suggestions", [])
        }
    
    def _generate_basic_correct_analysis(
        self,
        question_content: str,
        user_answer: str,
        correct_answer: str,
        explanation: str
    ) -> str:
        """生成基础正确答案分析（当LLM不可用时）"""
        return f"""
【做题思路分析】
解答这道题需要仔细分析题目条件，识别关键法律事实，并运用相关法律知识进行判断。

【为什么答案正确】
您的答案 {user_answer} 是正确的。
{explanation}

这道题涉及的核心知识点包括：
- 需要准确理解相关法律条文
- 正确识别题目中的关键信息
- 运用逻辑推理得出正确结论

建议您：
- 继续保持这种解题思路
- 巩固相关法律知识点
- 多做类似题目，提高解题熟练度
"""
    
    def _parse_analysis_text(self, analysis_text: str) -> Dict[str, Any]:
        """解析分析文本，提取结构化信息"""
        sections = {
            "thinking_approach": "",
            "correct_explanation": "",
            "error_analysis": "",
            "suggestions": []
        }
        
        # 简单的文本解析逻辑
        lines = analysis_text.split('\n')
        current_section = None
        
        for line in lines:
            line = line.strip()
            if not line:
                continue
            
            # 识别章节标题
            if '做题思路' in line or '解题思路' in line:
                current_section = "thinking_approach"
                continue
            elif '正确答案' in line or '正确解释' in line:
                current_section = "correct_explanation"
                continue
            elif '错误分析' in line or '错误原因' in line:
                current_section = "error_analysis"
                continue
            elif '建议' in line or '改进' in line:
                current_section = "suggestions"
                continue
            
            # 根据当前章节收集内容
            if current_section == "thinking_approach":
                sections["thinking_approach"] += line + "\n"
            elif current_section == "correct_explanation":
                sections["correct_explanation"] += line + "\n"
            elif current_section == "error_analysis":
                sections["error_analysis"] += line + "\n"
            elif current_section == "suggestions":
                if line.startswith('-') or line.startswith('•') or line.startswith('1.') or line.startswith('2.'):
                    sections["suggestions"].append(line.lstrip('- •123456789. '))
        
        return sections
    
    async def calculate_thinking_quality(
        self,
        user_id: str,
        recent_sessions: List[TrainingSession]
    ) -> float:
        """模拟思维质量计算"""
        if not recent_sessions:
            return 70.0
        
        # 基于准确率和答题速度计算思维质量
        total_accuracy = sum(s.accuracy_rate for s in recent_sessions) / len(recent_sessions)
        # 简单的思维质量分数
        thinking_quality = total_accuracy * 0.9 + 10  # 基础分数
        
        return min(100.0, max(0.0, thinking_quality))


# 工厂函数
def get_evaluation_engine() -> EvaluationEngine:
    """
    获取评估引擎实例
    
    Returns:
        评估引擎实例
    """
    # 可以返回基于机器学习的实现
    # return MLEvaluationEngine()
    
    # 默认返回模拟服务
    return MockEvaluationEngine()

